Termination w.r.t. Q proof of /home/nowonder/forschung/aprove/satrung/aprove/lpar14/CimeSLASHbig.trs

Termination w.r.t. Q of the following Term Rewriting System could not be shown:

Q restricted rewrite system:
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.

↳ QTRS

  ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.

Using Dependency Pairs [1,13] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

MEM₂(x, cons₂(y, l)) -> EQ₂(x, y)
*¹₂(*₂(x, y), z) -> *¹₂(y, z)
LOG'₁(1₁(x)) -> +¹₂(log'₁(x), 1₁(#))
PROD₁(app₂(l1, l2)) -> PROD₁(l2)
IFINTER₄(true, x, l1, l2) -> INTER₂(l1, l2)
-¹₂(0₁(x), 1₁(y)) -> -¹₂(-₂(x, y), 1₁(#))
SUM₁(app₂(l1, l2)) -> +¹₂(sum₁(l1), sum₁(l2))
INTER₂(l1, cons₂(x, l2)) -> MEM₂(x, l1)
LOG'₁(0₁(x)) -> LOG'₁(x)
*¹₂(x, +₂(y, z)) -> *¹₂(x, y)
GE₂(1₁(x), 0₁(y)) -> GE₂(x, y)
GE₂(0₁(x), 1₁(y)) -> GE₂(y, x)
*¹₂(*₂(x, y), z) -> *¹₂(x, *₂(y, z))
+¹₂(1₁(x), 1₁(y)) -> 0¹₁(+₂(+₂(x, y), 1₁(#)))
-¹₂(1₁(x), 0₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 1₁(y)) -> -¹₂(x, y)
INTER₂(l1, app₂(l2, l3)) -> INTER₂(l1, l3)
+¹₂(+₂(x, y), z) -> +¹₂(y, z)
PROD₁(app₂(l1, l2)) -> PROD₁(l1)
*¹₂(1₁(x), y) -> 0¹₁(*₂(x, y))
*¹₂(1₁(x), y) -> +¹₂(0₁(*₂(x, y)), y)
EQ₂(0₁(x), 0₁(y)) -> EQ₂(x, y)
APP₂(cons₂(x, l1), l2) -> APP₂(l1, l2)
MEM₂(x, cons₂(y, l)) -> IF₃(eq₂(x, y), true, mem₂(x, l))
LOG'₁(0₁(x)) -> GE₂(x, 1₁(#))
SUM₁(app₂(l1, l2)) -> SUM₁(l1)
GE₂(0₁(x), 1₁(y)) -> NOT₁(ge₂(y, x))
INTER₂(app₂(l1, l2), l3) -> INTER₂(l1, l3)
LOG'₁(0₁(x)) -> +¹₂(log'₁(x), 1₁(#))
PROD₁(cons₂(x, l)) -> *¹₂(x, prod₁(l))
INTER₂(l1, app₂(l2, l3)) -> INTER₂(l1, l2)
PROD₁(cons₂(x, l)) -> PROD₁(l)
*¹₂(x, +₂(y, z)) -> *¹₂(x, z)
*¹₂(0₁(x), y) -> *¹₂(x, y)
+¹₂(0₁(x), 1₁(y)) -> +¹₂(x, y)
+¹₂(1₁(x), 0₁(y)) -> +¹₂(x, y)
IFINTER₄(false, x, l1, l2) -> INTER₂(l1, l2)
+¹₂(1₁(x), 1₁(y)) -> +¹₂(+₂(x, y), 1₁(#))
SUM₁(nil) -> 0¹₁(#)
EQ₂(1₁(x), 1₁(y)) -> EQ₂(x, y)
INTER₂(app₂(l1, l2), l3) -> INTER₂(l2, l3)
-¹₂(1₁(x), 1₁(y)) -> 0¹₁(-₂(x, y))
EQ₂(0₁(x), #) -> EQ₂(x, #)
EQ₂(#, 0₁(y)) -> EQ₂(#, y)
+¹₂(0₁(x), 0₁(y)) -> +¹₂(x, y)
-¹₂(0₁(x), 0₁(y)) -> 0¹₁(-₂(x, y))
LOG₁(x) -> LOG'₁(x)
INTER₂(l1, cons₂(x, l2)) -> IFINTER₄(mem₂(x, l1), x, l2, l1)
*¹₂(x, +₂(y, z)) -> +¹₂(*₂(x, y), *₂(x, z))
*¹₂(1₁(x), y) -> *¹₂(x, y)
+¹₂(0₁(x), 0₁(y)) -> 0¹₁(+₂(x, y))
MEM₂(x, cons₂(y, l)) -> MEM₂(x, l)
LOG'₁(1₁(x)) -> LOG'₁(x)
SUM₁(cons₂(x, l)) -> +¹₂(x, sum₁(l))
LOG₁(x) -> -¹₂(log'₁(x), 1₁(#))
GE₂(1₁(x), 1₁(y)) -> GE₂(x, y)
+¹₂(1₁(x), 1₁(y)) -> +¹₂(x, y)
-¹₂(0₁(x), 0₁(y)) -> -¹₂(x, y)
SUM₁(app₂(l1, l2)) -> SUM₁(l2)
INTER₂(l1, app₂(l2, l3)) -> APP₂(inter₂(l1, l2), inter₂(l1, l3))
+¹₂(+₂(x, y), z) -> +¹₂(x, +₂(y, z))
SUM₁(cons₂(x, l)) -> SUM₁(l)
LOG'₁(0₁(x)) -> IF₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
GE₂(#, 0₁(x)) -> GE₂(#, x)
INTER₂(cons₂(x, l1), l2) -> IFINTER₄(mem₂(x, l2), x, l1, l2)
PROD₁(app₂(l1, l2)) -> *¹₂(prod₁(l1), prod₁(l2))
INTER₂(app₂(l1, l2), l3) -> APP₂(inter₂(l1, l3), inter₂(l2, l3))
*¹₂(0₁(x), y) -> 0¹₁(*₂(x, y))
GE₂(0₁(x), 0₁(y)) -> GE₂(x, y)
INTER₂(cons₂(x, l1), l2) -> MEM₂(x, l2)
-¹₂(1₁(x), 1₁(y)) -> -¹₂(x, y)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

MEM₂(x, cons₂(y, l)) -> EQ₂(x, y)
*¹₂(*₂(x, y), z) -> *¹₂(y, z)
LOG'₁(1₁(x)) -> +¹₂(log'₁(x), 1₁(#))
PROD₁(app₂(l1, l2)) -> PROD₁(l2)
IFINTER₄(true, x, l1, l2) -> INTER₂(l1, l2)
-¹₂(0₁(x), 1₁(y)) -> -¹₂(-₂(x, y), 1₁(#))
SUM₁(app₂(l1, l2)) -> +¹₂(sum₁(l1), sum₁(l2))
INTER₂(l1, cons₂(x, l2)) -> MEM₂(x, l1)
LOG'₁(0₁(x)) -> LOG'₁(x)
*¹₂(x, +₂(y, z)) -> *¹₂(x, y)
GE₂(1₁(x), 0₁(y)) -> GE₂(x, y)
GE₂(0₁(x), 1₁(y)) -> GE₂(y, x)
*¹₂(*₂(x, y), z) -> *¹₂(x, *₂(y, z))
+¹₂(1₁(x), 1₁(y)) -> 0¹₁(+₂(+₂(x, y), 1₁(#)))
-¹₂(1₁(x), 0₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 1₁(y)) -> -¹₂(x, y)
INTER₂(l1, app₂(l2, l3)) -> INTER₂(l1, l3)
+¹₂(+₂(x, y), z) -> +¹₂(y, z)
PROD₁(app₂(l1, l2)) -> PROD₁(l1)
*¹₂(1₁(x), y) -> 0¹₁(*₂(x, y))
*¹₂(1₁(x), y) -> +¹₂(0₁(*₂(x, y)), y)
EQ₂(0₁(x), 0₁(y)) -> EQ₂(x, y)
APP₂(cons₂(x, l1), l2) -> APP₂(l1, l2)
MEM₂(x, cons₂(y, l)) -> IF₃(eq₂(x, y), true, mem₂(x, l))
LOG'₁(0₁(x)) -> GE₂(x, 1₁(#))
SUM₁(app₂(l1, l2)) -> SUM₁(l1)
GE₂(0₁(x), 1₁(y)) -> NOT₁(ge₂(y, x))
INTER₂(app₂(l1, l2), l3) -> INTER₂(l1, l3)
LOG'₁(0₁(x)) -> +¹₂(log'₁(x), 1₁(#))
PROD₁(cons₂(x, l)) -> *¹₂(x, prod₁(l))
INTER₂(l1, app₂(l2, l3)) -> INTER₂(l1, l2)
PROD₁(cons₂(x, l)) -> PROD₁(l)
*¹₂(x, +₂(y, z)) -> *¹₂(x, z)
*¹₂(0₁(x), y) -> *¹₂(x, y)
+¹₂(0₁(x), 1₁(y)) -> +¹₂(x, y)
+¹₂(1₁(x), 0₁(y)) -> +¹₂(x, y)
IFINTER₄(false, x, l1, l2) -> INTER₂(l1, l2)
+¹₂(1₁(x), 1₁(y)) -> +¹₂(+₂(x, y), 1₁(#))
SUM₁(nil) -> 0¹₁(#)
EQ₂(1₁(x), 1₁(y)) -> EQ₂(x, y)
INTER₂(app₂(l1, l2), l3) -> INTER₂(l2, l3)
-¹₂(1₁(x), 1₁(y)) -> 0¹₁(-₂(x, y))
EQ₂(0₁(x), #) -> EQ₂(x, #)
EQ₂(#, 0₁(y)) -> EQ₂(#, y)
+¹₂(0₁(x), 0₁(y)) -> +¹₂(x, y)
-¹₂(0₁(x), 0₁(y)) -> 0¹₁(-₂(x, y))
LOG₁(x) -> LOG'₁(x)
INTER₂(l1, cons₂(x, l2)) -> IFINTER₄(mem₂(x, l1), x, l2, l1)
*¹₂(x, +₂(y, z)) -> +¹₂(*₂(x, y), *₂(x, z))
*¹₂(1₁(x), y) -> *¹₂(x, y)
+¹₂(0₁(x), 0₁(y)) -> 0¹₁(+₂(x, y))
MEM₂(x, cons₂(y, l)) -> MEM₂(x, l)
LOG'₁(1₁(x)) -> LOG'₁(x)
SUM₁(cons₂(x, l)) -> +¹₂(x, sum₁(l))
LOG₁(x) -> -¹₂(log'₁(x), 1₁(#))
GE₂(1₁(x), 1₁(y)) -> GE₂(x, y)
+¹₂(1₁(x), 1₁(y)) -> +¹₂(x, y)
-¹₂(0₁(x), 0₁(y)) -> -¹₂(x, y)
SUM₁(app₂(l1, l2)) -> SUM₁(l2)
INTER₂(l1, app₂(l2, l3)) -> APP₂(inter₂(l1, l2), inter₂(l1, l3))
+¹₂(+₂(x, y), z) -> +¹₂(x, +₂(y, z))
SUM₁(cons₂(x, l)) -> SUM₁(l)
LOG'₁(0₁(x)) -> IF₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
GE₂(#, 0₁(x)) -> GE₂(#, x)
INTER₂(cons₂(x, l1), l2) -> IFINTER₄(mem₂(x, l2), x, l1, l2)
PROD₁(app₂(l1, l2)) -> *¹₂(prod₁(l1), prod₁(l2))
INTER₂(app₂(l1, l2), l3) -> APP₂(inter₂(l1, l3), inter₂(l2, l3))
*¹₂(0₁(x), y) -> 0¹₁(*₂(x, y))
GE₂(0₁(x), 0₁(y)) -> GE₂(x, y)
INTER₂(cons₂(x, l1), l2) -> MEM₂(x, l2)
-¹₂(1₁(x), 1₁(y)) -> -¹₂(x, y)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 14 SCCs with 26 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

APP₂(cons₂(x, l1), l2) -> APP₂(l1, l2)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

APP₂(cons₂(x, l1), l2) -> APP₂(l1, l2)

The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
APP₂(x1, x2) = APP₁(x1)
cons₂(x1, x2) = cons₁(x2)

Lexicographic Path Order [19].
Precedence:

[APP₁, cons_1]

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

GE₂(#, 0₁(x)) -> GE₂(#, x)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

GE₂(#, 0₁(x)) -> GE₂(#, x)

The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
GE₂(x1, x2) = GE₁(x2)
# = #
0₁(x1) = 0₁(x1)

Lexicographic Path Order [19].
Precedence:

[#, 0_1] > GE₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

GE₂(1₁(x), 1₁(y)) -> GE₂(x, y)
GE₂(0₁(x), 0₁(y)) -> GE₂(x, y)
GE₂(1₁(x), 0₁(y)) -> GE₂(x, y)
GE₂(0₁(x), 1₁(y)) -> GE₂(y, x)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

EQ₂(0₁(x), #) -> EQ₂(x, #)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

EQ₂(0₁(x), #) -> EQ₂(x, #)

The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
EQ₂(x1, x2) = EQ₁(x1)
0₁(x1) = 0₁(x1)
# = #

Lexicographic Path Order [19].
Precedence:

[0₁, #] > EQ₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

EQ₂(#, 0₁(y)) -> EQ₂(#, y)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

EQ₂(#, 0₁(y)) -> EQ₂(#, y)

The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
EQ₂(x1, x2) = EQ₁(x2)
# = #
0₁(x1) = 0₁(x1)

Lexicographic Path Order [19].
Precedence:

[#, 0_1] > EQ₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

EQ₂(1₁(x), 1₁(y)) -> EQ₂(x, y)
EQ₂(0₁(x), 0₁(y)) -> EQ₂(x, y)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

EQ₂(0₁(x), 0₁(y)) -> EQ₂(x, y)

The remaining pairs can at least by weakly be oriented.

EQ₂(1₁(x), 1₁(y)) -> EQ₂(x, y)

Used ordering: Combined order from the following AFS and order.
EQ₂(x1, x2) = x2
1₁(x1) = x1
0₁(x1) = 0₁(x1)

Lexicographic Path Order [19].
Precedence:

trivial

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

EQ₂(1₁(x), 1₁(y)) -> EQ₂(x, y)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

EQ₂(1₁(x), 1₁(y)) -> EQ₂(x, y)

The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
EQ₂(x1, x2) = EQ₁(x1)
1₁(x1) = 1₁(x1)

Lexicographic Path Order [19].
Precedence:

trivial

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

MEM₂(x, cons₂(y, l)) -> MEM₂(x, l)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

MEM₂(x, cons₂(y, l)) -> MEM₂(x, l)

The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
MEM₂(x1, x2) = MEM₁(x2)
cons₂(x1, x2) = cons₁(x2)

Lexicographic Path Order [19].
Precedence:

[MEM₁, cons_1]

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

INTER₂(l1, cons₂(x, l2)) -> IFINTER₄(mem₂(x, l1), x, l2, l1)
INTER₂(l1, app₂(l2, l3)) -> INTER₂(l1, l3)
INTER₂(cons₂(x, l1), l2) -> IFINTER₄(mem₂(x, l2), x, l1, l2)
INTER₂(l1, app₂(l2, l3)) -> INTER₂(l1, l2)
IFINTER₄(true, x, l1, l2) -> INTER₂(l1, l2)
INTER₂(app₂(l1, l2), l3) -> INTER₂(l2, l3)
INTER₂(app₂(l1, l2), l3) -> INTER₂(l1, l3)
IFINTER₄(false, x, l1, l2) -> INTER₂(l1, l2)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

-¹₂(1₁(x), 0₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 1₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 0₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 1₁(y)) -> -¹₂(-₂(x, y), 1₁(#))
-¹₂(1₁(x), 1₁(y)) -> -¹₂(x, y)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

-¹₂(0₁(x), 1₁(y)) -> -¹₂(x, y)
-¹₂(1₁(x), 1₁(y)) -> -¹₂(x, y)

The remaining pairs can at least by weakly be oriented.

-¹₂(1₁(x), 0₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 0₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 1₁(y)) -> -¹₂(-₂(x, y), 1₁(#))

Used ordering: Combined order from the following AFS and order.
-¹₂(x1, x2) = -¹₁(x2)
1₁(x1) = 1₁(x1)
0₁(x1) = x1
-₂(x1, x2) = -
# = #

Lexicographic Path Order [19].
Precedence:

[1₁, -] > -^1₁ > #

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

-¹₂(1₁(x), 0₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 0₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 1₁(y)) -> -¹₂(-₂(x, y), 1₁(#))

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 2 SCCs.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ DependencyGraphProof

                  ↳ AND

                    ↳ QDP

                      ↳ QDPOrderProof

                    ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

-¹₂(0₁(x), 1₁(y)) -> -¹₂(-₂(x, y), 1₁(#))

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

-¹₂(0₁(x), 1₁(y)) -> -¹₂(-₂(x, y), 1₁(#))

The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
-¹₂(x1, x2) = -¹₂(x1, x2)
0₁(x1) = 0₁(x1)
1₁(x1) = 1₁(x1)
-₂(x1, x2) = x1
# = #

Lexicographic Path Order [19].
Precedence:

[-^1₂, 0₁, 1_1] > #

The following usable rules [14] were oriented:

-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
0₁(#) -> #

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ DependencyGraphProof

                  ↳ AND

                    ↳ QDP

                      ↳ QDPOrderProof

                        ↳ QDP

                          ↳ PisEmptyProof

                    ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ DependencyGraphProof

                  ↳ AND

                    ↳ QDP

                    ↳ QDP

                      ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

-¹₂(1₁(x), 0₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 0₁(y)) -> -¹₂(x, y)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

-¹₂(1₁(x), 0₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 0₁(y)) -> -¹₂(x, y)

The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
-¹₂(x1, x2) = x2
1₁(x1) = x1
0₁(x1) = 0₁(x1)

Lexicographic Path Order [19].
Precedence:

trivial

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ DependencyGraphProof

                  ↳ AND

                    ↳ QDP

                    ↳ QDP

                      ↳ QDPOrderProof

                        ↳ QDP

                          ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

+¹₂(0₁(x), 0₁(y)) -> +¹₂(x, y)
+¹₂(1₁(x), 1₁(y)) -> +¹₂(x, y)
+¹₂(+₂(x, y), z) -> +¹₂(y, z)
+¹₂(1₁(x), 0₁(y)) -> +¹₂(x, y)
+¹₂(0₁(x), 1₁(y)) -> +¹₂(x, y)
+¹₂(+₂(x, y), z) -> +¹₂(x, +₂(y, z))
+¹₂(1₁(x), 1₁(y)) -> +¹₂(+₂(x, y), 1₁(#))

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SUM₁(app₂(l1, l2)) -> SUM₁(l1)
SUM₁(app₂(l1, l2)) -> SUM₁(l2)
SUM₁(cons₂(x, l)) -> SUM₁(l)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

SUM₁(app₂(l1, l2)) -> SUM₁(l1)
SUM₁(app₂(l1, l2)) -> SUM₁(l2)

The remaining pairs can at least by weakly be oriented.

SUM₁(cons₂(x, l)) -> SUM₁(l)

Used ordering: Combined order from the following AFS and order.
SUM₁(x1) = SUM₁(x1)
app₂(x1, x2) = app₂(x1, x2)
cons₂(x1, x2) = x2

Lexicographic Path Order [19].
Precedence:

app₂ > SUM₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SUM₁(cons₂(x, l)) -> SUM₁(l)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

SUM₁(cons₂(x, l)) -> SUM₁(l)

The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
SUM₁(x1) = SUM₁(x1)
cons₂(x1, x2) = cons₂(x1, x2)

Lexicographic Path Order [19].
Precedence:

cons₂ > SUM₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

*¹₂(*₂(x, y), z) -> *¹₂(y, z)
*¹₂(x, +₂(y, z)) -> *¹₂(x, z)
*¹₂(1₁(x), y) -> *¹₂(x, y)
*¹₂(x, +₂(y, z)) -> *¹₂(x, y)
*¹₂(0₁(x), y) -> *¹₂(x, y)
*¹₂(*₂(x, y), z) -> *¹₂(x, *₂(y, z))

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

*¹₂(*₂(x, y), z) -> *¹₂(y, z)
*¹₂(*₂(x, y), z) -> *¹₂(x, *₂(y, z))

The remaining pairs can at least by weakly be oriented.

*¹₂(x, +₂(y, z)) -> *¹₂(x, z)
*¹₂(1₁(x), y) -> *¹₂(x, y)
*¹₂(x, +₂(y, z)) -> *¹₂(x, y)
*¹₂(0₁(x), y) -> *¹₂(x, y)

Used ordering: Combined order from the following AFS and order.
*¹₂(x1, x2) = *¹₁(x1)
*₂(x1, x2) = *₂(x1, x2)
+₂(x1, x2) = +₂(x1, x2)
1₁(x1) = x1
0₁(x1) = x1
# = #

Lexicographic Path Order [19].
Precedence:

# > [*^1₁, *₂, +_2]

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

*¹₂(x, +₂(y, z)) -> *¹₂(x, z)
*¹₂(1₁(x), y) -> *¹₂(x, y)
*¹₂(x, +₂(y, z)) -> *¹₂(x, y)
*¹₂(0₁(x), y) -> *¹₂(x, y)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

*¹₂(1₁(x), y) -> *¹₂(x, y)

The remaining pairs can at least by weakly be oriented.

*¹₂(x, +₂(y, z)) -> *¹₂(x, z)
*¹₂(x, +₂(y, z)) -> *¹₂(x, y)
*¹₂(0₁(x), y) -> *¹₂(x, y)

Used ordering: Combined order from the following AFS and order.
*¹₂(x1, x2) = *¹₁(x1)
+₂(x1, x2) = x1
1₁(x1) = 1₁(x1)
0₁(x1) = x1

Lexicographic Path Order [19].
Precedence:

trivial

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

*¹₂(x, +₂(y, z)) -> *¹₂(x, z)
*¹₂(x, +₂(y, z)) -> *¹₂(x, y)
*¹₂(0₁(x), y) -> *¹₂(x, y)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

*¹₂(x, +₂(y, z)) -> *¹₂(x, z)
*¹₂(x, +₂(y, z)) -> *¹₂(x, y)
*¹₂(0₁(x), y) -> *¹₂(x, y)

The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
*¹₂(x1, x2) = *¹₂(x1, x2)
+₂(x1, x2) = +₂(x1, x2)
0₁(x1) = 0₁(x1)

Lexicographic Path Order [19].
Precedence:

trivial

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROD₁(app₂(l1, l2)) -> PROD₁(l2)
PROD₁(cons₂(x, l)) -> PROD₁(l)
PROD₁(app₂(l1, l2)) -> PROD₁(l1)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

PROD₁(app₂(l1, l2)) -> PROD₁(l2)
PROD₁(app₂(l1, l2)) -> PROD₁(l1)

The remaining pairs can at least by weakly be oriented.

PROD₁(cons₂(x, l)) -> PROD₁(l)

Used ordering: Combined order from the following AFS and order.
PROD₁(x1) = PROD₁(x1)
app₂(x1, x2) = app₂(x1, x2)
cons₂(x1, x2) = x2

Lexicographic Path Order [19].
Precedence:

app₂ > PROD₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROD₁(cons₂(x, l)) -> PROD₁(l)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

PROD₁(cons₂(x, l)) -> PROD₁(l)

The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
PROD₁(x1) = PROD₁(x1)
cons₂(x1, x2) = cons₂(x1, x2)

Lexicographic Path Order [19].
Precedence:

cons₂ > PROD₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

LOG'₁(1₁(x)) -> LOG'₁(x)
LOG'₁(0₁(x)) -> LOG'₁(x)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

LOG'₁(0₁(x)) -> LOG'₁(x)

The remaining pairs can at least by weakly be oriented.

LOG'₁(1₁(x)) -> LOG'₁(x)

Used ordering: Combined order from the following AFS and order.
LOG'₁(x1) = LOG'₁(x1)
1₁(x1) = x1
0₁(x1) = 0₁(x1)

Lexicographic Path Order [19].
Precedence:

trivial

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

LOG'₁(1₁(x)) -> LOG'₁(x)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

LOG'₁(1₁(x)) -> LOG'₁(x)

The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
LOG'₁(x1) = LOG'₁(x1)
1₁(x1) = 1₁(x1)

Lexicographic Path Order [19].
Precedence:

1₁ > LOG'₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.